\documentclass[10pt,a4paper]{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
% Interactive index
\usepackage{hyperref}
% Spanish titles
\usepackage[spanish]{babel}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
% Code listings
\usepackage{listings}
\lstset{
 language=Lisp,
 numbers=left,
 numberstyle=\footnotesize,
 stepnumber=0,
%
 tabsize=2,
 breaklines=true,
 breakatwhitespace=false,
 showstringspaces=false,
 showtabs=false,
%
 frame=none
%
 escapeinside={\% ;}
}
% Make lists without bullets
\renewenvironment{itemize}{
 \begin{list}{}{
  \setlength{\leftmargin}{1.5em}
 }
}{
 \end{list}
}

\begin{document}

\section{Sintaxis, S-expressions}

Common Lisp usa S-expressions para denotar tanto el código como la estructura de datos. 
Los elementos básicos de las S-expressions son las listas y los átomos.
Las listas están limitadas por paréntesis y cualquier número de espacios separando elementos. Átomos se refiere a todo lo demás (números, cadenas y nombres).

\subsection{Átomos}

\subsubsection{Números}

Cualquier secuencia de digitos--posiblemente precedidos por un signo, conteniendo un punto decimal(.), una barra(/),o terminando con un exponente-- es un número válido.

Algunos ejemplos:
\begin{itemize}
\item 123	  ;;El entero 123 
\item 3/7	  ;;La fraccion tres séptimos 
\item 1.0	  ;;El número 1.0 en punto flotante con precicion simple 
\item 1.0e0	  ;;Otra manera de escribir el mismo número 
\item 1.0d0	  ;;El numero 1.0 en punto flotante con doble precisión
\item 1.0e-4  ;;El numero 0.0001 en punto flotante
\item 1.0d-4  ;;El numero 0.0001 en punto flotante con doble precisión
\item +42	  ;;El número positivo 42
\item -42	  ;;El número negativo -42
\item -1/4	  ;;La fracción -1/4
\item -2/8	  ;;Otra forma de escribir -1/4
\item 246/2	  ;;Otra forma de escribir el entero 123

\end{itemize}

Lisp también soporta números complejos.

\#C(1 2)	; 1 + 2i

\subsubsection{Strings}

Los Strings estan encerrados entre dobles comillas.
Con una barra puedo escapar el próximo caracter, haciendo que este sea incluido en la cadena sin importar que sea. Los únicos dos caracteres que deben ser incluidos de esta manera son las dobles comillas y la raba.


Algunos ejemplos:
\begin{verbatim}
“foo” 	 ;;La cadena que contiene los caracteres f, o, y o
“fo\o”	 ;;La misma cadena
“fo\o”	 ;;La cadena que contine los caracteres f, o,  \, y o
“fo\”o” ;;La cadena que contiene los caracteres f, o, “ y o
\end{verbatim}

\subsubsection{Nombres}

Los nombres que se que se usan en los programas de Lisp tales como Format y hello-world(función) estan representados por objetos llamados símbolos.El reader no sabe nada acerca de como un nombre se va a usar, si es el nombre de una variable, funcion o algo mas.El solo lee una secuencia de caracteres y construye un objeto para representar el nombre.

\subsubsection*{Caracteres prohibidos}

Los caracteres siguientes no pueden ser incluidos en los nombres:
“, ', /, \, whitespace, (, ), y  ` .


\subsubsection*{Conversiones a simbolos}
Cuando se lee el nombre el reader convierte el nombre a su equivalente en mayúsculas (hello-world ==> HELLO-WORLD) .

Por lo tanto foo, Foo, y FOO son tratados como el mismo simbolo :FOO.

\subsubsection*{Unicidad}

Luego de esta conversion el reader se fija en una tabla de símbolos llamada package por un símbolo existente con el mismo nombre.Si no lo encuentra este crea un simbolo nuevo y lo agrega a la tabla. Sino, devuelve el símbolo que ya esta en la tabla.

\subsection{Listas como S-expressions}

Aunque volveremos a hablar mas especificamente sobre listas por ahora es importante entender como combinar números strings y símbolos con parentesis delimitando listas para construir expresiones representando árboles de objetos arbitrarios.
\begin{itemize}
\item () 				;;Lista vacía
\item (1 2 3)			;;Lista que contiene 1, 2 y 3
\item (“foo” “bar”)		;;Lista con dos strings
\item (x 1 “foo”)		;;Lista con un símbolo, un nombre y un string
\item (+ (* 2 3) 4) 	;;Lista con el símbolo , una lista, y un número
\end{itemize}

\textbf{Ejemplo}

(defun hello-world () (format t “hello, world”)) ;;La lista que contiene dos símbolos, la lista vacia y otra lista, que contiene dos símbolos y un string.
\newline
\newline
No Todas las expresiones S son código Lisp válido.(Cualquier átomo o cualquier lista que tenga como primer elemento un simbolo es codigo de Lisp válido)

\section{Variables} 
\subsection{Características básicas}

Como en otros lenguajes, las variables en  Common Lisp son lugares con nombre que pueden contener un valor.

Las variables no son de un tipo tal como en Java o C++. Esto quiere decir que  no se debe especificar el tipo de objeto que cada variable puede almacenar. Entonces Common Lisp es dinámicamente tipado, lo que significa que los errores de tipos son detectados en tiempo de ejecución.
Por otra parte, Common Lisp es fuertemente tipado en el sentido de que todos los errores de tipos seran detectados, no hay forma de tratar a un objeto como una instancia de una clase que no es.
Observación:
Se puede deshabilitar el chequeo de tipos en ciertas regiones de código ( en general con motivos de optimización).

Todos los valores en Common Lisp son referencias a objetos. Consecuentemente, asignar un valor nuevo a una variable cambia a que objeto la variable se refiere pero no tiene efecto en el objeto antes referenciado. De esta forma si la variable contiene una referencia a un objeto mutable  se puede usar para modificar el objeto y la modificacion será visible a cualquier porción de código que tenga una referencia a ese objeto
Como una optimización ciertos tipos de objetos, tales como enteros por debajo de un cierto tamaño puede ser representados directaente en memoria donde otros objetos serían representados como un puntero al objeto actual. De todas formas como los enteros so inmutables no hay tanto problema de que halla multiples copias “del mismo” objeto in diferentes variables.
Una forma de introducir nuevas variables es definir parametros en una función, cada vez que se llame a esa función Lisp creara nuevos bindings para almacenar los argumentos pasados por quien llamo la función.

Por ejemplo, esta función define 3 variables x,y,z  para almacenar sus argumentos:
\begin{lstlisting}
(defun foo (x y z (+ x y z))
\end{lstlisting}
Un binding es la manifestacion en tiempo de ejecución de una variable.Una sola variable puede tener multiples bindings al mismo tiempo.

Como todas las variables en Commom Lisp, los parametros de una función guardan referencias a objetos.Entonces, puedes asignar un nuevo valor a un parámetro dentro del cuerpo de la funcion, y no afectara a los bindings creados por otra llamada a la misma función.Pero si el objeto que se pasa a la función es mutable y se cambia dentro del cuerpo, el cambio sera visible a todas las variables que referencien al mismo objeto.

Otra forma de introducir nuevas variables es el operador \textbf{LET}. Las binding forms se pueden declarar de la siguiente forma:

\begin{lstlisting}
(let (variables) body-form)
\end{lstlisting}

Una variante es el operador \textbf{LET*} con el que se puede hacer referencia a variables creadas en la misma definición.


Ejemplo:
\begin{lstlisting}
(let ((x 10) (y 20) z) body)
\end{lstlisting}

Cuando el LET es evaluado nuevos bindings son creados y inicializados antes que el body sea ejecutado.
El scope de las variables introducidas con LET está delimitado desde la declaración de las variables hasta el fin del body de la instrucción.
Esta forma  de definir variables con LET es llamada binding form.

Cada referecia a una variable se referira al binding con el menor scope que la contenga.

Ejemplo:
\begin{lstlisting}
(defun foo (x)							
	(format t "Parametro: ~a~%" x)	;;  X es el argumento
	(let(x 2)							
		(format t "Let de afuera: ~a~%" x);;X es 2		
		(let (x 3)							
			(format t "Let de adentro: ~a~%" x));;X es 3	
		(format t "Let de afuera: ~a~%" x))				
	(format t "Parametro: ~a~%" x))				
\end{lstlisting}
\subsection{Tipos de variables}


Existen 2 tipos de variables en Commom Lisp, las variables léxicas y las variables dinámicas.

\subsubsection{Variables Léxicas}

Por defecto todas las biinding forms en Commom Lisp introduce variables con scope léxico.
Las variables lexicas pueden ser referidas solo por el codigo que esta textualmente dentro de la binding form.
Este tipo de variables tiene que ser familiar para cualquiera que halla programado en Java, C, Perl o Phyton ya que todos ellos proveen variables locales con scope léxico.

Sin embargo, las variables léxicas en Commom Lisp son variables léxicas con algunas diferencias. Las diferencias está proporcionada por la combinacion del scope léxico y las funciones anidadas, lo que da origen a los \textbf{closures}:

\begin{lstlisting}
(let ((contador 0)) #'(lambda () (setf contador (+ 1 contador))))
\end{lstlisting}

La referencia a count debería ser legal de acuerdo con las reglas del scope léxico, sin embargo , la función anónima conteniendo la referencia sera devuelta como valor del LET y podrá ser invocada mediante FUNCALL por código que no  esta dentro del scope del LET.
Este ejemplo funcionará siempre y cuando contador sea una variable léxica. La función anónima es llamada “CLOSURE” porque captura el binding creado por el let.

\subsubsection{Variables dinámicas}


Las variables con scope léxico sirven para mantener el codigo entendible limitando el scope en el cual una misma variable tiene significado. Esta es la razón por la que los lenguajes modernos usan variables con scope léxico para variables locales. Pero algunas veces, necesitamos variables globales, variables a las que uno pueda referirse desde cualquier lado en el programa.Mientras que es verdad que el uso indiscriminado de las variables globales crea un programa inentendible y desordenado hay usos realmente buenos de éstas.
La version de Lisp de las variables globales, las variables dinámicas son mas útiles y manejables.
Lisp provee dos maneras de declarar variables globales \textbf{DEFVAR} y \textbf{DEFPARAMETER}.


Defvar

\begin{lstlisting}
(defvar *name* value)
	"Documentacion")
\end{lstlisting}

Defparameter

\begin{lstlisting}
(defparameter *name* value)
	"Documentacion")
Siempre asigna un valor inicial.
\end{lstlisting}

\subsubsection{Constantes}

Otra clase de variable la contradictoria “variable constante”. 
Todas las constantes son globales y están definidas con DEFCONSTANT.

\begin{lstlisting}
(defconstant nombre valorInicial "documentacion")
\end{lstlisting}

Al igual que con DEFVAR y DEFPARAMETER , DEFCONSTANT tiene un efecto global en el nombre usado. El 
nombre de una constante no puede ser usado como nombre de un parámetro de una función.
No se pueden cambiar sus valores excepto redefiniendo la variable pero no es aconsejable porque no se peude estar seguro de que en algunos lados la constante tenga un valor mas antiguo.Por lo tanto es aconsejable usar constantes solo en los casos que lo que retenga mi variable realmente sea una constante.

\subsection{Asignación}

Una vez que tenemos un binding  podemos hacer dos cosas: obtener el valor actual y setearle un nuevo valor. Como ya hemos mencionado un símbolo se evalua al valor de la variable al que nombra, por lo tanto se puede obtener el valor de una variable simplemente refiriendose a la variable.Para asignar un nuevo valor al binding, se puede usar el macro SETF.

La forma básica del SETF es de la forma:

\begin{lstlisting}
(setf place valor)
\end{lstlisting}

Porque SETF es un macro, puede examinar la forma que tiene el place y expandirlo en una cantidad apropiada de operaciones debajo nivel para manipularlo.Cuando place es una variable, éste se expande en una llamada a un operador especial llamado SETQ, el cual, como un operador especial, tiene acceso a los bindings léxicos y dinámicos.

\begin{lstlisting}
(setf x (setf y (random 10))) 
\end{lstlisting}

Setf retorna el valor recién asignado.



\subsubsection{Asignación generalizada}

Los binding sobre variables, por supuesto, no son los únicos lugares que pueden almacenar valores.Commom Lisp soporta estructras de datos compuestas tales como arrays, hash tables, y listas y tipos definidos por el usuario.
Se debe notar que SETF puede asignar en cualquiér lugar un valor tal como es la asignación con el operador “=” en lenguajes como JAVA, C, C++ , etc.


\end{document}